home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / distutils / fancy_getopt.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  8.8 KB  |  320 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __revision__ = '$Id: fancy_getopt.py 37828 2004-11-10 22:23:15Z loewis $'
  5. import sys
  6. import string
  7. import re
  8. from types import *
  9. import getopt
  10. from distutils.errors import *
  11. longopt_pat = '[a-zA-Z](?:[a-zA-Z0-9-]*)'
  12. longopt_re = re.compile('^%s$' % longopt_pat)
  13. neg_alias_re = re.compile('^(%s)=!(%s)$' % (longopt_pat, longopt_pat))
  14. longopt_xlate = string.maketrans('-', '_')
  15.  
  16. class FancyGetopt:
  17.     
  18.     def __init__(self, option_table = None):
  19.         self.option_table = option_table
  20.         self.option_index = { }
  21.         if self.option_table:
  22.             self._build_index()
  23.         
  24.         self.alias = { }
  25.         self.negative_alias = { }
  26.         self.short_opts = []
  27.         self.long_opts = []
  28.         self.short2long = { }
  29.         self.attr_name = { }
  30.         self.takes_arg = { }
  31.         self.option_order = []
  32.  
  33.     
  34.     def _build_index(self):
  35.         self.option_index.clear()
  36.         for option in self.option_table:
  37.             self.option_index[option[0]] = option
  38.         
  39.  
  40.     
  41.     def set_option_table(self, option_table):
  42.         self.option_table = option_table
  43.         self._build_index()
  44.  
  45.     
  46.     def add_option(self, long_option, short_option = None, help_string = None):
  47.         if self.option_index.has_key(long_option):
  48.             raise DistutilsGetoptError, "option conflict: already an option '%s'" % long_option
  49.         else:
  50.             option = (long_option, short_option, help_string)
  51.             self.option_table.append(option)
  52.             self.option_index[long_option] = option
  53.  
  54.     
  55.     def has_option(self, long_option):
  56.         return self.option_index.has_key(long_option)
  57.  
  58.     
  59.     def get_attr_name(self, long_option):
  60.         return string.translate(long_option, longopt_xlate)
  61.  
  62.     
  63.     def _check_alias_dict(self, aliases, what):
  64.         for alias, opt in aliases.items():
  65.             if not self.option_index.has_key(alias):
  66.                 raise DistutilsGetoptError, "invalid %s '%s': option '%s' not defined" % (what, alias, alias)
  67.             
  68.             if not self.option_index.has_key(opt):
  69.                 raise DistutilsGetoptError, "invalid %s '%s': aliased option '%s' not defined" % (what, alias, opt)
  70.                 continue
  71.         
  72.  
  73.     
  74.     def set_aliases(self, alias):
  75.         self._check_alias_dict(alias, 'alias')
  76.         self.alias = alias
  77.  
  78.     
  79.     def set_negative_aliases(self, negative_alias):
  80.         self._check_alias_dict(negative_alias, 'negative alias')
  81.         self.negative_alias = negative_alias
  82.  
  83.     
  84.     def _grok_option_table(self):
  85.         self.long_opts = []
  86.         self.short_opts = []
  87.         self.short2long.clear()
  88.         self.repeat = { }
  89.         for option in self.option_table:
  90.             if len(option) == 3:
  91.                 (long, short, help) = option
  92.                 repeat = 0
  93.             elif len(option) == 4:
  94.                 (long, short, help, repeat) = option
  95.             else:
  96.                 raise ValueError, 'invalid option tuple: %r' % (option,)
  97.             if type(long) is not StringType or len(long) < 2:
  98.                 raise DistutilsGetoptError, "invalid long option '%s': must be a string of length >= 2" % long
  99.             
  100.             if not short is None and type(short) is StringType and len(short) == 1:
  101.                 raise DistutilsGetoptError, "invalid short option '%s': must a single character or None" % short
  102.             
  103.             self.repeat[long] = repeat
  104.             self.long_opts.append(long)
  105.             if long[-1] == '=':
  106.                 if short:
  107.                     short = short + ':'
  108.                 
  109.                 long = long[0:-1]
  110.                 self.takes_arg[long] = 1
  111.             else:
  112.                 alias_to = self.negative_alias.get(long)
  113.                 if alias_to is not None:
  114.                     if self.takes_arg[alias_to]:
  115.                         raise DistutilsGetoptError, "invalid negative alias '%s': aliased option '%s' takes a value" % (long, alias_to)
  116.                     
  117.                     self.long_opts[-1] = long
  118.                     self.takes_arg[long] = 0
  119.                 else:
  120.                     self.takes_arg[long] = 0
  121.             alias_to = self.alias.get(long)
  122.             if alias_to is not None:
  123.                 if self.takes_arg[long] != self.takes_arg[alias_to]:
  124.                     raise DistutilsGetoptError, "invalid alias '%s': inconsistent with aliased option '%s' (one of them takes a value, the other doesn't" % (long, alias_to)
  125.                 
  126.             
  127.             if not longopt_re.match(long):
  128.                 raise DistutilsGetoptError, ("invalid long option name '%s' " + '(must be letters, numbers, hyphens only') % long
  129.             
  130.             self.attr_name[long] = self.get_attr_name(long)
  131.             if short:
  132.                 self.short_opts.append(short)
  133.                 self.short2long[short[0]] = long
  134.                 continue
  135.         
  136.  
  137.     
  138.     def getopt(self, args = None, object = None):
  139.         if args is None:
  140.             args = sys.argv[1:]
  141.         
  142.         if object is None:
  143.             object = OptionDummy()
  144.             created_object = 1
  145.         else:
  146.             created_object = 0
  147.         self._grok_option_table()
  148.         short_opts = string.join(self.short_opts)
  149.         
  150.         try:
  151.             (opts, args) = getopt.getopt(args, short_opts, self.long_opts)
  152.         except getopt.error:
  153.             msg = None
  154.             raise DistutilsArgError, msg
  155.  
  156.         for opt, val in opts:
  157.             if len(opt) == 2 and opt[0] == '-':
  158.                 opt = self.short2long[opt[1]]
  159.             else:
  160.                 opt = opt[2:]
  161.             alias = self.alias.get(opt)
  162.             if alias:
  163.                 opt = alias
  164.             
  165.             if not self.takes_arg[opt]:
  166.                 alias = self.negative_alias.get(opt)
  167.                 if alias:
  168.                     opt = alias
  169.                     val = 0
  170.                 else:
  171.                     val = 1
  172.             
  173.             attr = self.attr_name[opt]
  174.             if val and self.repeat.get(attr) is not None:
  175.                 val = getattr(object, attr, 0) + 1
  176.             
  177.             setattr(object, attr, val)
  178.             self.option_order.append((opt, val))
  179.         
  180.         if created_object:
  181.             return (args, object)
  182.         else:
  183.             return args
  184.  
  185.     
  186.     def get_option_order(self):
  187.         if self.option_order is None:
  188.             raise RuntimeError, "'getopt()' hasn't been called yet"
  189.         else:
  190.             return self.option_order
  191.  
  192.     
  193.     def generate_help(self, header = None):
  194.         max_opt = 0
  195.         for option in self.option_table:
  196.             long = option[0]
  197.             short = option[1]
  198.             l = len(long)
  199.             if long[-1] == '=':
  200.                 l = l - 1
  201.             
  202.             if short is not None:
  203.                 l = l + 5
  204.             
  205.             if l > max_opt:
  206.                 max_opt = l
  207.                 continue
  208.         
  209.         opt_width = max_opt + 2 + 2 + 2
  210.         line_width = 78
  211.         text_width = line_width - opt_width
  212.         big_indent = ' ' * opt_width
  213.         if header:
  214.             lines = [
  215.                 header]
  216.         else:
  217.             lines = [
  218.                 'Option summary:']
  219.         for option in self.option_table:
  220.             (long, short, help) = option[:3]
  221.             text = wrap_text(help, text_width)
  222.             if long[-1] == '=':
  223.                 long = long[0:-1]
  224.             
  225.             if short is None:
  226.                 if text:
  227.                     lines.append('  --%-*s  %s' % (max_opt, long, text[0]))
  228.                 else:
  229.                     lines.append('  --%-*s  ' % (max_opt, long))
  230.             else:
  231.                 opt_names = '%s (-%s)' % (long, short)
  232.                 if text:
  233.                     lines.append('  --%-*s  %s' % (max_opt, opt_names, text[0]))
  234.                 else:
  235.                     lines.append('  --%-*s' % opt_names)
  236.             for l in text[1:]:
  237.                 lines.append(big_indent + l)
  238.             
  239.         
  240.         return lines
  241.  
  242.     
  243.     def print_help(self, header = None, file = None):
  244.         if file is None:
  245.             file = sys.stdout
  246.         
  247.         for line in self.generate_help(header):
  248.             file.write(line + '\n')
  249.         
  250.  
  251.  
  252.  
  253. def fancy_getopt(options, negative_opt, object, args):
  254.     parser = FancyGetopt(options)
  255.     parser.set_negative_aliases(negative_opt)
  256.     return parser.getopt(args, object)
  257.  
  258. WS_TRANS = string.maketrans(string.whitespace, ' ' * len(string.whitespace))
  259.  
  260. def wrap_text(text, width):
  261.     if text is None:
  262.         return []
  263.     
  264.     if len(text) <= width:
  265.         return [
  266.             text]
  267.     
  268.     text = string.expandtabs(text)
  269.     text = string.translate(text, WS_TRANS)
  270.     chunks = re.split('( +|-+)', text)
  271.     chunks = filter(None, chunks)
  272.     lines = []
  273.     while chunks:
  274.         cur_line = []
  275.         cur_len = 0
  276.         while chunks:
  277.             l = len(chunks[0])
  278.             if cur_len + l <= width:
  279.                 cur_line.append(chunks[0])
  280.                 del chunks[0]
  281.                 cur_len = cur_len + l
  282.                 continue
  283.             if cur_line and cur_line[-1][0] == ' ':
  284.                 del cur_line[-1]
  285.             
  286.             break
  287.         if chunks:
  288.             if cur_len == 0:
  289.                 cur_line.append(chunks[0][0:width])
  290.                 chunks[0] = chunks[0][width:]
  291.             
  292.             if chunks[0][0] == ' ':
  293.                 del chunks[0]
  294.             
  295.         
  296.         lines.append(string.join(cur_line, ''))
  297.     return lines
  298.  
  299.  
  300. def translate_longopt(opt):
  301.     return string.translate(opt, longopt_xlate)
  302.  
  303.  
  304. class OptionDummy:
  305.     
  306.     def __init__(self, options = []):
  307.         for opt in options:
  308.             setattr(self, opt, None)
  309.         
  310.  
  311.  
  312. if __name__ == '__main__':
  313.     text = 'Tra-la-la, supercalifragilisticexpialidocious.\nHow *do* you spell that odd word, anyways?\n(Someone ask Mary -- she\'ll know [or she\'ll\nsay, "How should I know?"].)'
  314.     for w in (10, 20, 30, 40):
  315.         print 'width: %d' % w
  316.         print string.join(wrap_text(text, w), '\n')
  317.         print 
  318.     
  319.  
  320.